home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / email / charset.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  6.1 KB  |  216 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __all__ = [
  5.     'Charset',
  6.     'add_alias',
  7.     'add_charset',
  8.     'add_codec']
  9. import email.base64mime as email
  10. import email.quoprimime as email
  11. from email import errors
  12. from email.encoders import encode_7or8bit
  13. QP = 1
  14. BASE64 = 2
  15. SHORTEST = 3
  16. MISC_LEN = 7
  17. DEFAULT_CHARSET = 'us-ascii'
  18. CHARSETS = {
  19.     'iso-8859-1': (QP, QP, None),
  20.     'iso-8859-2': (QP, QP, None),
  21.     'iso-8859-3': (QP, QP, None),
  22.     'iso-8859-4': (QP, QP, None),
  23.     'iso-8859-9': (QP, QP, None),
  24.     'iso-8859-10': (QP, QP, None),
  25.     'iso-8859-13': (QP, QP, None),
  26.     'iso-8859-14': (QP, QP, None),
  27.     'iso-8859-15': (QP, QP, None),
  28.     'windows-1252': (QP, QP, None),
  29.     'viscii': (QP, QP, None),
  30.     'us-ascii': (None, None, None),
  31.     'big5': (BASE64, BASE64, None),
  32.     'gb2312': (BASE64, BASE64, None),
  33.     'euc-jp': (BASE64, None, 'iso-2022-jp'),
  34.     'shift_jis': (BASE64, None, 'iso-2022-jp'),
  35.     'iso-2022-jp': (BASE64, None, None),
  36.     'koi8-r': (BASE64, BASE64, None),
  37.     'utf-8': (SHORTEST, BASE64, 'utf-8'),
  38.     '8bit': (None, BASE64, 'utf-8') }
  39. ALIASES = {
  40.     'latin_1': 'iso-8859-1',
  41.     'latin-1': 'iso-8859-1',
  42.     'latin_2': 'iso-8859-2',
  43.     'latin-2': 'iso-8859-2',
  44.     'latin_3': 'iso-8859-3',
  45.     'latin-3': 'iso-8859-3',
  46.     'latin_4': 'iso-8859-4',
  47.     'latin-4': 'iso-8859-4',
  48.     'latin_5': 'iso-8859-9',
  49.     'latin-5': 'iso-8859-9',
  50.     'latin_6': 'iso-8859-10',
  51.     'latin-6': 'iso-8859-10',
  52.     'latin_7': 'iso-8859-13',
  53.     'latin-7': 'iso-8859-13',
  54.     'latin_8': 'iso-8859-14',
  55.     'latin-8': 'iso-8859-14',
  56.     'latin_9': 'iso-8859-15',
  57.     'latin-9': 'iso-8859-15',
  58.     'cp949': 'ks_c_5601-1987',
  59.     'euc_jp': 'euc-jp',
  60.     'euc_kr': 'euc-kr',
  61.     'ascii': 'us-ascii' }
  62. CODEC_MAP = {
  63.     'gb2312': 'eucgb2312_cn',
  64.     'big5': 'big5_tw',
  65.     'us-ascii': None }
  66.  
  67. def add_charset(charset, header_enc = None, body_enc = None, output_charset = None):
  68.     if body_enc == SHORTEST:
  69.         raise ValueError('SHORTEST not allowed for body_enc')
  70.     
  71.     CHARSETS[charset] = (header_enc, body_enc, output_charset)
  72.  
  73.  
  74. def add_alias(alias, canonical):
  75.     ALIASES[alias] = canonical
  76.  
  77.  
  78. def add_codec(charset, codecname):
  79.     CODEC_MAP[charset] = codecname
  80.  
  81.  
  82. class Charset:
  83.     
  84.     def __init__(self, input_charset = DEFAULT_CHARSET):
  85.         
  86.         try:
  87.             if isinstance(input_charset, unicode):
  88.                 input_charset.encode('ascii')
  89.             else:
  90.                 input_charset = unicode(input_charset, 'ascii')
  91.         except UnicodeError:
  92.             raise errors.CharsetError(input_charset)
  93.  
  94.         input_charset = input_charset.lower()
  95.         self.input_charset = ALIASES.get(input_charset, input_charset)
  96.         (henc, benc, conv) = CHARSETS.get(self.input_charset, (SHORTEST, BASE64, None))
  97.         if not conv:
  98.             conv = self.input_charset
  99.         
  100.         self.header_encoding = henc
  101.         self.body_encoding = benc
  102.         self.output_charset = ALIASES.get(conv, conv)
  103.         self.input_codec = CODEC_MAP.get(self.input_charset, self.input_charset)
  104.         self.output_codec = CODEC_MAP.get(self.output_charset, self.output_charset)
  105.  
  106.     
  107.     def __str__(self):
  108.         return self.input_charset.lower()
  109.  
  110.     __repr__ = __str__
  111.     
  112.     def __eq__(self, other):
  113.         return str(self) == str(other).lower()
  114.  
  115.     
  116.     def __ne__(self, other):
  117.         return not self.__eq__(other)
  118.  
  119.     
  120.     def get_body_encoding(self):
  121.         if self.body_encoding == QP:
  122.             return 'quoted-printable'
  123.         elif self.body_encoding == BASE64:
  124.             return 'base64'
  125.         else:
  126.             return encode_7or8bit
  127.  
  128.     
  129.     def convert(self, s):
  130.         if self.input_codec != self.output_codec:
  131.             return unicode(s, self.input_codec).encode(self.output_codec)
  132.         else:
  133.             return s
  134.  
  135.     
  136.     def to_splittable(self, s):
  137.         if isinstance(s, unicode) or self.input_codec is None:
  138.             return s
  139.         
  140.         
  141.         try:
  142.             return unicode(s, self.input_codec, 'replace')
  143.         except LookupError:
  144.             return s
  145.  
  146.  
  147.     
  148.     def from_splittable(self, ustr, to_output = True):
  149.         if to_output:
  150.             codec = self.output_codec
  151.         else:
  152.             codec = self.input_codec
  153.         if not isinstance(ustr, unicode) or codec is None:
  154.             return ustr
  155.         
  156.         
  157.         try:
  158.             return ustr.encode(codec, 'replace')
  159.         except LookupError:
  160.             return ustr
  161.  
  162.  
  163.     
  164.     def get_output_charset(self):
  165.         if not self.output_charset:
  166.             pass
  167.         return self.input_charset
  168.  
  169.     
  170.     def encoded_header_len(self, s):
  171.         cset = self.get_output_charset()
  172.         if self.header_encoding == BASE64:
  173.             return email.base64mime.base64_len(s) + len(cset) + MISC_LEN
  174.         elif self.header_encoding == QP:
  175.             return email.quoprimime.header_quopri_len(s) + len(cset) + MISC_LEN
  176.         elif self.header_encoding == SHORTEST:
  177.             lenb64 = email.base64mime.base64_len(s)
  178.             lenqp = email.quoprimime.header_quopri_len(s)
  179.             return min(lenb64, lenqp) + len(cset) + MISC_LEN
  180.         else:
  181.             return len(s)
  182.  
  183.     
  184.     def header_encode(self, s, convert = False):
  185.         cset = self.get_output_charset()
  186.         if convert:
  187.             s = self.convert(s)
  188.         
  189.         if self.header_encoding == BASE64:
  190.             return email.base64mime.header_encode(s, cset)
  191.         elif self.header_encoding == QP:
  192.             return email.quoprimime.header_encode(s, cset, maxlinelen = None)
  193.         elif self.header_encoding == SHORTEST:
  194.             lenb64 = email.base64mime.base64_len(s)
  195.             lenqp = email.quoprimime.header_quopri_len(s)
  196.             if lenb64 < lenqp:
  197.                 return email.base64mime.header_encode(s, cset)
  198.             else:
  199.                 return email.quoprimime.header_encode(s, cset, maxlinelen = None)
  200.         else:
  201.             return s
  202.  
  203.     
  204.     def body_encode(self, s, convert = True):
  205.         if convert:
  206.             s = self.convert(s)
  207.         
  208.         if self.body_encoding is BASE64:
  209.             return email.base64mime.body_encode(s)
  210.         elif self.body_encoding is QP:
  211.             return email.quoprimime.body_encode(s)
  212.         else:
  213.             return s
  214.  
  215.  
  216.